var utils = {}
utils.diff = function() {}
//获取url
utils.getUrlKey = function(name) {
    return decodeURIComponent((new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)').exec(location.href) || [, ""])[1].replace(/\+/g, '%20')) || null
}
// 数组深拷贝
utils.deepClone = function(obj) {
    return JSON.parse(JSON.stringify(obj))
}
utils.sliceClone = function(arr) {
    return arr.slice()
}
// 一个数组中去除在另一个数组中的 部分 如果 有paraName 则根据paraName区筛选 追加参数4 是否修改原数组 默认不修改
utils.spilceFromAnoherArr = function(a, b, paraName, bool) {
    var d
    if(!bool) {
        d = JSON.parse(JSON.stringify(a))
    } else {
        d = a
    }
    if(paraName) {
        for(var m = 0; m < d.length; m++) {
            for(var n = 0; n < b.length; n++) {
                if(d[m][paraName] == b[n][paraName]) {
                    d.splice(m, 1)
                }
            }
        }
    } else {
        //该方法有问题
        for(var m = 0; m < a.length; m++) {
            for(var n = 0; n < b.length; n++) {
                if(d[m] == b[n]) {
                    d.splice(m, 1)
                }
            }
        }
    }
    return d
}

utils.formatBool = function(bool, res, arr) {
    //参数1 bool值 true 为数字到bool false为bool到数字 参数2  需要格式化的数组 参数3 需要格式化的key值 数组
    var data
    data = res.map(function(item) {
        for(var i = 0; i < arr.length; i++) {
            if(bool) {
                if(item[arr[i]] === 0) {
                    item[arr[i]] = false
                } else if(item[arr[i]] === 1) {
                    item[arr[i]] = true
                }
            } else {
                if(item[arr[i]] === false) {
                    item[arr[i]] = 0
                } else if(item[arr[i]] === true) {
                    item[arr[i]] = 1
                }
            }
        }
        return item

    })
    return data
}
utils.changePositonArrByIndex = function(self, arr, i, bool) {
    // 数组相邻 两元素 互换位置 专业与vue 观察模式的数组 普通数组 目前不提供方法 可自行写
    // 参数 vue 1 this对象 2待交换的数组 3待交换位置的数组index 4 以前一个还是后一个元素为基准 默认与后一个交换
    if(!bool) {
        if(i > 0) {
            var tempOption = arr[i - 1];
            self.$set(arr, i - 1, arr[i]);
            self.$set(arr, i, tempOption)
        }
    } else {
        if(i < arr.length - 1) {
            var tempOption = arr[i + 1];
            self.$set(arr, i + 1, arr[i]);
            self.$set(arr, i, tempOption)
        }
    }

}

utils.productArrContinue = function(maxId) {
    // 生成连续指定长度的 数组
    var emptyArr = []
    for(var i = 0; i < maxId; i++) {
        emptyArr[i] = i + 1
    }
    return emptyArr
}

utils._diffArr = function(arr1, arr2, paraName) {
    // 返回两个数组 相对 第一个数组 不同的部分
    // 如 arr1 = [1,2,3,4,5] arr2 = [1]  return  [2,3,4,5]
    var a = [];
    var b = [];

    for(var i = 0; i < arr2.length; i++) {
        a[arr2[i]] = true;
    }

    for(var i = 0; i < arr1.length; i++) {
        if(!a[arr1[i]]) {
            b.push(arr1[i]);
        }
    }
    return b

}
utils.filterArr = function(arr, key, bool) {
    var emptyArr = []
    for(var i = 0; i < arr.length; i++) {
        if(bool) {

            if(arr[i].type != key) {
                emptyArr.push(arr[i])
            }
        } else {
            if(arr[i].type == key) {
                emptyArr.push(arr[i])
            }
        }

    }
    return emptyArr
}
// 对象数组 字段 合并去重 改变原数组
utils.mergeArr = function(arr1, arr2, key) {
    for(var i = 0; i < arr2.length; i++) {
        var flag = false
        for(var j = 0; j < arr1.length; j++) {
            if(arr2[i][key] == arr1[j][key]) {
                flag = true
                break
            }
        }
        if(!flag) {
            arr1.push(arr2[i])
        }
    }
    return arr1
}
// 根据 key值判断是否在数组中

utils.indexOfByKey = function(arr, item, key1, key2,callback) {
    for(var i = 0; i < arr.length; i++) {
        if(key2) {
            if(arr[i][key2] == item[key1]) {
                callback&&callback(i)
                return i
            }
        } else {
            if(arr[i][key1] == item[key1]) {
                callback&&callback()
                return i
            }
        }

    }

    return -1
}
// 根据指定key 值 将一个 数组 加入另一个数组

utils.addByKey = function(arr1, arr2, key1, key2, callback1, callback2) {
    for(var i = 0; i < arr2.length; i++) {
        for(var j = 0; j < arr1.length; j++) {
            if(arr1[j][key1] == arr2[i].data[key2]) {
                if(callback1) {
                    callback1(arr2[i], arr1[j])
                }
            }

        }
        if(callback2) {
            callback2(arr2[i])
        }
    }

}
utils.recurArr = function(arr, key) {
    let flag = true;
    var arr = [];

    function judgeChildren(arr) {
        arr.forEach(e => {
            if(!flag) {
                return
            }
            if(!e.value) {
                flag = false;
                return;
            } else if(e.children && e.children.length) {
                judgeChildren(e.children);
            }
        });
    }
    judgeChildren(arr);
    return flag;
}

/// 在树形 结构 中 ztree 复杂模式 查找  某个值 是否相等
/**
 * 深度递归搜索
 * @param {Array} arr 你要搜索的数组
 * @param {Function} condition 回调函数，必须返回谓词，判断是否找到了。会传入(item, index, level)三个参数
 * @param {String} condition 条件的key
 * @param {String} children 子数组的key
 * @param {String} condition 判断相等的 具体值
 * @param {Function} 自定义回调函数
 * change by huangweiping
 */
utils.deepFind = (arr, condition, children, key, value, callback) => {
    // 即将返回的数组
    let main = []

    // 用try方案方便直接中止所有递归的程序
    try {
        // 开始轮询
        (function poll(arr, level) {
            // 如果传入非数组
            if(!Array.isArray(arr)) return

            // 遍历数组
            for(let i = 0; i < arr.length; i++) {
                // 获取当前项
                const item = arr[i]

                // 先占位预设值
                main[level] = item

                // 检验是否已经找到了
                const isFind = condition && condition(item, i, level, key, value, callback) || false

                // 如果已经找到了  修改 --2019.7.24  默认查找所有
//				if(isFind) {
//
//					// 直接抛出错误中断所有轮询
//					throw Error
//
//					// 如果存在children，那么深入递归
//				} else
                if(children && item[children] && item[children].length) {
                    poll(item[children], level + 1)

                    // 如果是最后一个且没有找到值，那么通过修改数组长度来删除当前项
                } else if(i === arr.length - 1) {
                    // 删除占位预设值
                    main.length = main.length - 1
                }
            }
        })(arr, 0)
        // 使用try/catch是为了中止所有轮询中的任务
    } catch(err) {
        throw err
    }

    // 返回最终数组
    return main
}
// 将 ztree 简单数据 结构 转化为标准json 数据结构
utils.convert=  function(list) {
    var res = []
    var  map = list.reduce((res, v) => (res[v.id] = v, res), {})
    for (var item of list) {
        if (item.parentId === 0) {
            res.push(item)
            continue
        }
        if (item.parentId in map) {
            var parent = map[item.parentId]
            parent.children = parent.children || []
            parent.children.push(item)
        }
    }
    return res
}
// 分钟数转小时分钟  例如 372 转化为 06：12
utils.forMateSunTime = function(t){
    var hour = parseInt(t / 60)
    hour = hour < 10 ? ('0'+hour) : hour
    var minite = t % 60
    minite = minite < 10 ? ('0'+minite) : minite
    return hour + ":" + minite
}

//不足四位补零
utils.formatZero=function(num, len=4) {
    if(String(num).length > len) return num;
    return (Array(len).join(0) + num).slice(-len);
}

//对象数组 根据字段排序 up 0 升序 1 降序
utils.compare = function(arr,key,up){
    var compare = function(key){
        return function(value1,value2){
            var val1=value1[key];
            var val2=value2[key];
            if(up){
                return val1-val2
            }else{
                return val2-val1;
            }
        }
    }
    return arr.sort(compare(key))
}




export default utils